home *** CD-ROM | disk | FTP | other *** search
/ Aminet 21 / Aminet 21 (1997)(GTI - Schatztruhe)[!][Oct 1997].iso / Aminet / gfx / show / gs_src_gs.lha / gs5.03 / gzht.h < prev    next >
C/C++ Source or Header  |  1997-05-13  |  8KB  |  184 lines
  1. /* Copyright (C) 1989, 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gzht.h */
  20. /* Private halftone representation for Ghostscript */
  21. /* Requires gxdevice.h, gxdcolor.h */
  22. #include "gscsel.h"
  23. #include "gxht.h"
  24. #include "gxfmap.h"
  25. #include "gxdht.h"
  26. #include "gxhttile.h"
  27.  
  28. /* Sort a sampled halftone order by sample value. */
  29. void gx_sort_ht_order(P2(gx_ht_bit *, uint));
  30.  
  31. /* (Internal) procedures for constructing halftone orders. */
  32. int gx_ht_alloc_order(P6(gx_ht_order *porder, uint width, uint height,
  33.              uint strip_shift, uint num_levels, gs_memory_t *mem));
  34. void gx_ht_construct_spot_order(P1(gx_ht_order *));
  35. void gx_ht_construct_threshold_order(P2(gx_ht_order *, const byte *));
  36. void gx_ht_construct_bits(P1(gx_ht_order *));
  37.  
  38. /* Halftone enumeration structure */
  39. struct gs_screen_enum_s {
  40.     gs_halftone halftone;    /* supplied by client */
  41.     gx_ht_order order;
  42.     gs_matrix mat;        /* for mapping device x,y to rotated cell */
  43.     int x, y;
  44.     int strip, shift;
  45.     gs_state *pgs;
  46. };
  47. #define private_st_gs_screen_enum() /* in gshtscr.c */\
  48.   gs_private_st_composite(st_gs_screen_enum, gs_screen_enum,\
  49.     "gs_screen_enum", screen_enum_enum_ptrs, screen_enum_reloc_ptrs)
  50. /*    order.levels, order.bits, pgs)*/
  51.  
  52. /* Prepare a device halftone for installation, but don't install it. */
  53. int gs_sethalftone_prepare(P3(gs_state *, gs_halftone *,
  54.                   gx_device_halftone *));
  55.  
  56. /* Allocate and initialize a spot screen. */
  57. /* This is the first half of gs_screen_init_accurate/memory. */
  58. int gs_screen_order_init_memory(P5(gx_ht_order *, const gs_state *,
  59.                    gs_screen_halftone *, bool, gs_memory_t *));
  60. #define gs_screen_order_init(porder, pgs, phsp, accurate)\
  61.   gs_screen_order_init_memory(porder, pgs, phsp, accurate, pgs->memory)
  62.  
  63. /* Prepare to sample a spot screen. */
  64. /* This is the second half of gs_screen_init_accurate/memory. */
  65. int gs_screen_enum_init_memory(P5(gs_screen_enum *, const gx_ht_order *,
  66.                   gs_state *, gs_screen_halftone *,
  67.                   gs_memory_t *));
  68. #define gs_screen_enum_init(penum, porder, pgs, phsp)\
  69.   gs_screen_enum_init_memory(penum, porder, pgs, phsp, pgs->memory)
  70.  
  71. /* Process an entire screen plane. */
  72. int gx_ht_process_screen_memory(P5(gs_screen_enum *penum, gs_state *pgs,
  73.                    gs_screen_halftone *phsp, bool accurate,
  74.                    gs_memory_t *mem));
  75. #define gx_ht_process_screen(penum, pgs, phsp, accurate)\
  76.   gx_ht_process_screen_memory(penum, pgs, phsp, accurate, pgs->memory)
  77.  
  78. /*
  79.  * We don't want to remember all the values of the halftone screen,
  80.  * because they would take up space proportional to P^3, where P is
  81.  * the number of pixels in a cell.  Instead, we pick some number N of
  82.  * patterns to cache.  Each cache slot covers a range of (P+1)/N
  83.  * different gray levels: we "slide" the contents of the slot back and
  84.  * forth within this range by incrementally adding and dropping 1-bits.
  85.  * N>=0 (obviously); N<=P+1 (likewise); also, so that we can simplify things
  86.  * by preallocating the bookkeeping information for the cache, we define
  87.  * a constant max_cached_tiles which is an a priori maximum value for N.
  88.  *
  89.  * Note that the raster for each tile must be a multiple of bitmap_align_mod,
  90.  * to satisfy the copy_mono device routine, even though a multiple of
  91.  * sizeof(ht_mask_t) would otherwise be sufficient.
  92.  */
  93.  
  94. struct gx_ht_cache_s {
  95.     /* The following are set when the cache is created. */
  96.     byte *bits;            /* the base of the bits */
  97.     uint bits_size;            /* the space available for bits */
  98.     gx_ht_tile *ht_tiles;        /* the base of the tiles */
  99.     uint num_tiles;            /* the number of tiles allocated */
  100.     /* The following are reset each time the cache is initialized */
  101.     /* for a new screen. */
  102.     gx_ht_order order;        /* the cached order vector */
  103.     int num_cached;            /* actual # of cached tiles */
  104.     int levels_per_tile;        /* # of levels per cached tile */
  105.     gx_bitmap_id base_id;        /* the base id, to which */
  106.                     /* we add the halftone level */
  107. };
  108. /* We don't mark from the tiles pointer, and we relocate the tiles en masse. */
  109. #define private_st_ht_tiles()    /* in gxht.c */\
  110.   gs_private_st_composite(st_ht_tiles, gx_ht_tile, "ht tiles",\
  111.     ht_tiles_enum_ptrs, ht_tiles_reloc_ptrs)
  112. #define private_st_ht_cache()    /* in gxht.c */\
  113.   gs_private_st_ptrs_add2(st_ht_cache, gx_ht_cache, "ht cache",\
  114.     ht_cache_enum_ptrs, ht_cache_reloc_ptrs,\
  115.     st_ht_order, order, bits, ht_tiles)
  116.  
  117. /* Compute a fractional color for dithering, the correctly rounded */
  118. /* quotient f * max_gx_color_value / maxv. */
  119. #define frac_color_(f, maxv)\
  120.   (gx_color_value)(((f) * (0xffffL * 2) + maxv) / (maxv * 2))
  121. extern const gx_color_value _ds *fc_color_quo[8];
  122. #define fractional_color(f, maxv)\
  123.   ((maxv) <= 7 ? fc_color_quo[maxv][f] : frac_color_(f, maxv))
  124.  
  125. /* ------ Halftone cache procedures ------ */
  126.  
  127. /* Allocate/free a halftone cache. */
  128. uint gx_ht_cache_default_tiles(P0());
  129. uint gx_ht_cache_default_bits(P0());
  130. gx_ht_cache *gx_ht_alloc_cache(P3(gs_memory_t *, uint, uint));
  131. void gx_ht_free_cache(P2(gs_memory_t *, gx_ht_cache *));
  132.  
  133. /* Clear a halftone cache. */
  134. #define gx_ht_clear_cache(pcache)\
  135.   ((pcache)->order.levels = 0, (pcache)->order.bits = 0,\
  136.    (pcache)->ht_tiles[0].tiles.data = 0)
  137.  
  138. /* Initialize a halftone cache with a given order. */
  139. void gx_ht_init_cache(P2(gx_ht_cache *, const gx_ht_order *));
  140.  
  141. /* Make the cache order current, and return whether */
  142. /* there is room for all possible tiles in the cache. */
  143. bool gx_check_tile_cache(P1(const gs_imager_state *));
  144.  
  145. /* Determine whether a given (width, y, height) might fit into a */
  146. /* single tile. If so, return the byte offset of the appropriate row */
  147. /* from the beginning of the tile, and set *ppx to the x phase offset */
  148. /* within the tile; if not, return -1. */
  149. int gx_check_tile_size(P6(const gs_imager_state *pis, int w, int y, int h,
  150.               gs_color_select_t select, int *ppx));
  151.  
  152. /* Make a given level current in a halftone cache. */
  153. gx_ht_tile *gx_render_ht(P2(gx_ht_cache *, int));
  154.  
  155. /* ------ Device halftone management ------ */
  156.  
  157. /* Release a gx_ht_order by freeing its components. */
  158. /* (Don't free the gx_device_halftone itself.) */
  159. void gx_ht_order_release(P3(gx_ht_order *porder, gs_memory_t *mem, bool free_cache));
  160.  
  161. /*
  162.  * Install a device halftone in an imager state.
  163.  * Note that this does not read or update the client halftone.
  164.  */
  165. int gx_imager_dev_ht_install(P4(gs_imager_state *pis,
  166.                 const gx_device_halftone *pdht,
  167.                 gs_halftone_type type,
  168.                 const gx_device *dev));
  169.  
  170. /*
  171.  * Install a new halftone in the graphics state.  Note that we copy the top
  172.  * level of the gs_halftone and the gx_device_halftone, and take ownership
  173.  * of any substructures.
  174.  */
  175. int gx_ht_install(P3(gs_state *, const gs_halftone *,
  176.              const gx_device_halftone *));
  177.  
  178. /* Reestablish the effective transfer functions, taking into account */
  179. /* any overrides from halftone dictionaries. */
  180. /* Some compilers object to names longer than 31 characters.... */
  181. void gx_imager_set_effective_xfer(P1(gs_imager_state *pis));
  182. void gx_set_effective_transfer(P1(gs_state *pgs));
  183.  
  184.